home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / var_tab.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-21  |  3.4 KB  |  163 lines
  1. #include "var_tab.h"
  2. #include <alloc.h>
  3.  
  4. VarTable::VarTable()
  5.     {
  6.     used = 0;
  7.     size = STEP;
  8.     table = new Variable*[STEP];
  9.     }
  10. //////////////////////
  11. VarTable::~VarTable()
  12.     {
  13.     for(; used > 0; used--)
  14.         delete table[used];
  15.     delete table;
  16.     }
  17. //////////////////////
  18. void VarTable::add(Variable* v)
  19.     {
  20.     if(size == used)
  21.         table = (Variable**)realloc((Variable**)table,
  22.                (size += STEP) * sizeof(Variable*));
  23.     table[++used] = v;
  24.     }
  25. //////////////////////
  26. int VarTable::assign(double d, char* name)
  27.     {
  28.     Variable* v;
  29.     if((v = find(name)) == NULL)
  30.         {
  31.         v = new Variable(d, name);
  32.     add(v);
  33.         return 1;
  34.         }
  35.     v->type = REAL;
  36.     v->d = d;
  37.     return 1;
  38.     }
  39. //////////////////////
  40. int VarTable::assign(char* s, char* name)
  41.     {
  42.     Variable* v;
  43.     if((v = find(name)) == NULL)
  44.         {
  45.         v = new Variable(s, name);
  46.     add(v);
  47.         return 1;
  48.         }
  49.     v->type = STR;
  50.     delete v->s;
  51.     v->s = strdup(s);
  52.     return 1;
  53.     }
  54. //////////////////////
  55. int VarTable::assign(double* da, char* name)
  56.     {
  57.     Variable* v;
  58.     if((v = find(name)) == NULL)
  59.         {
  60.         v = new Variable(da, name);
  61.     add(v);
  62.         return 1;
  63.         }
  64.     v->type = ARRAY;
  65.     delete v->da;
  66.     v->da = new double[da[0] + 1];
  67.       memcpy(v->da, da, (da[0] + 1) * sizeof(double));
  68.     return 1;
  69.     }
  70. ////////////////////
  71. int VarTable::assign(int index, char* name)
  72.     {
  73.     Variable* v;
  74.     if((v = find(name)) == NULL)
  75.         {
  76.     v = new Variable(index, name);
  77.         add(v);
  78.         }
  79.     else
  80.         {
  81.     if(v->type == ARRAY)
  82.             {
  83.         delete v->da;
  84.             v->da = new double[index + 1];
  85.             memcpy(v->da, 0, index * sizeof(double));
  86.             return 1;
  87.             }
  88.         return 0;
  89.         }
  90.     return 1;
  91.     }
  92. //////////////////////
  93. int VarTable::assign(double d, char* name, int index)
  94.     {
  95.     Variable* v;
  96.     if((v = find(name)) == NULL)
  97.         {
  98. /*        v = new Variable(da, name);
  99.     add(v);
  100. */        return 0;
  101.         }
  102.     v->type = ARRAY;
  103.     v->da[index] = d;
  104.     return 1;
  105.     }
  106. //////////////////////
  107. int VarTable::assign(Variable* v)
  108.     {
  109.     Variable* v1;
  110.     if((v1 = find(v->name)) == NULL)
  111.         {
  112.         add(v);
  113.         return 1;
  114.         }
  115.  
  116.     v1->type = v->type;
  117.  
  118.     switch(v->type)
  119.         {
  120.         case REAL: v1->d = v->d; break;
  121.         case STR: delete v1->s; v1->s = strdup(v->s); break;
  122.         case ARRAY: delete v1->da; v->da = new double[v->da[0] + 1];
  123.       memcpy(v1->da, v->da, (v->da[0] + 1) * sizeof(double));
  124.         }
  125.     delete v;
  126.     return 1;
  127.     }
  128. //////////////////////
  129. Variable* VarTable::remove(char* name)
  130.     {
  131.     Variable* v;
  132.     for(int i = 1; i <= used; i++)
  133.         {
  134.         if(strcmp(name, table[i]->name))
  135.             continue;
  136.         else
  137.             {
  138.             v = table[i];
  139.         break;
  140.             }
  141.         }
  142.     for(; i < used; i++)
  143.         table[i] = table[i + 1];
  144.     used--;
  145.     return v;
  146.     }
  147. ////////////////////
  148. Variable* VarTable::find(char* name)
  149.     {
  150.     Variable* v = NULL;
  151.     for(int i = 1; i <= used; i++)
  152.         {
  153.         if(strcmp(name, table[i]->name))
  154.             continue;
  155.         else
  156.             {
  157.             v = table[i];
  158.         break;
  159.             }
  160.         }
  161.     return v;
  162.     }
  163.